// const arr = [1,[2,3],[4,5,[6,7,[8,9]]]]
// // 多为数组转一维数组
// const flatten = (arr) => {
//   const result = []
//   for (let i = 0; i < arr.length; i++) {
//     const item = arr[i]
//     if (Array.isArray(item)) {
//       const flat = flatten(item)
//       for (let j = 0; j < flat.length; j++) {
//         result.push(flat[j])
//       }
//     } else {
//       result.push(item)
//     }
//   }
//   return result
// }
// console.log(flatten(arr))

// =============== 扁平数据：用于数组转树练习 ===============
// 说明：pid 为空字符串表示根节点；其余为父节点 id。
const flatData = [
  { id: '01', pid: '',   name: '张大大',   job: '项目经理' },
  { id: '02', pid: '01', name: '小黄',     job: '产品leader' },
  { id: '03', pid: '',   name: '小李',     job: 'UIdesigner' },
  { id: '04', pid: '03', name: '老马',     job: '技术leader' },
  { id: '05', pid: '01', name: '老王',     job: '测试leader' },
  { id: '06', pid: '02', name: '小周',     job: '产品经理' },
  { id: '07', pid: '02', name: '小吴',     job: '交互设计' },
  { id: '08', pid: '05', name: '小郑',     job: '测试工程师' },
  { id: '09', pid: '04', name: '小赵',     job: '前端工程师' },
  { id: '10', pid: '04', name: '小钱',     job: '后端工程师' }
]
const arrayToTree = (data, pid) => {
  // 定义结果变量、
  let result = []
  // 遍历数据
  for(let i = 0; i < data.length; i++) {
    // 获取当前元素
    let item = data[i]
    // 如果pid为空，则将当前元素添加到结果中
    if(item.pid === pid) {
      // result.push(item)
      const children = arrayToTree(data, item.id)
      if(children.length > 0) {
        item.children = children
      }
      result.push(item)
    }
    return result
  }
}
// 你的任务：在此处自行实现数组转树函数
// 要求：根据 flatData 中的 id/pid 构造成树结构（children 字段）
// 示例：
// function arrayToTree(data, pid) { /* TODO: 你来实现 */ }
// const tree = arrayToTree(flatData, '')
// console.log(JSON.stringify(tree, null, 2))

// 为了便于其它文件引用测试，可导出数据（可删）
if (typeof module !== 'undefined' && module.exports) {
  module.exports.flatData = flatData
}

// // 多维数组求和
// const deepSum = (arr) => {
//   let sum = 0
//   for (let i = 0; i < arr.length; i++) {
//     const item = arr[i]
//     if (Array.isArray(item)) {
//       sum += deepSum(item)
//     } else {
//       const n = Number(item)
//       if (!Number.isNaN(n)) sum += n
//     }
//   }
//   return sum
// }

// // 多维数组求平均值
// const deepSumAndCount = (arr) => {
//   let sum = 0
//   let count = 0
//   for (let i = 0; i < arr.length; i++) {
//     const item = arr[i]
//     if (Array.isArray(item)) {
//       const result = deepSumAndCount(item)
//       sum += result.sum
//       count += result.count
//     } else {
//       const n = Number(item)
//       if (!Number.isNaN(n)) {
//         sum += n
//         count += 1
//       }
//     }
//   }
//   return { sum, count }
// }

// const deepAverage = (arr) => {
//   const { sum, count } = deepSumAndCount(arr)
//   return count === 0 ? NaN : sum / count
// }

// console.log('sum:', deepSum(arr))
// console.log('avg:', deepAverage(arr))

// // ================== 常见数组类面试算法（原生写法） ==================

// // 1) 数组转树（哈希映射法 O(n)）
// const arrayToTree = (items, idKey = 'id', parentKey = 'parentId', childrenKey = 'children', rootParentValues = [null, undefined, 0]) => {
//   if (!Array.isArray(items) || items.length === 0) return []
//   const nodes = []
//   for (let i = 0; i < items.length; i++) nodes.push({ ...items[i] })
//   const idToNode = new Map()
//   const roots = []
//   for (let i = 0; i < nodes.length; i++) {
//     const n = nodes[i]
//     if (!Object.prototype.hasOwnProperty.call(n, childrenKey)) n[childrenKey] = []
//     idToNode.set(n[idKey], n)
//   }
//   for (let i = 0; i < nodes.length; i++) {
//     const n = nodes[i]
//     const pid = n[parentKey]
//     let isRoot = false
//     for (let j = 0; j < rootParentValues.length; j++) {
//       if (rootParentValues[j] === pid) { isRoot = true; break }
//     }
//     if (isRoot) { roots.push(n); continue }
//     const p = idToNode.get(pid)
//     if (p) p[childrenKey].push(n)
//     else roots.push(n)
//   }
//   return roots
// }

// // 2) 树转数组（先序 DFS）
// const treeToArray = (roots, childrenKey = 'children') => {
//   const result = []
//   const stack = Array.isArray(roots) ? roots.slice() : [roots]
//   while (stack.length) {
//     const node = stack.pop()
//     const shallow = { ...node }
//     delete shallow[childrenKey]
//     result.push(shallow)
//     const children = node && node[childrenKey]
//     if (Array.isArray(children) && children.length) {
//       for (let i = children.length - 1; i >= 0; i--) stack.push(children[i])
//     }
//   }
//   return result
// }

// // 3) 去重（保持顺序）
// const unique = (arr) => {
//   const seen = new Set()
//   const res = []
//   for (let i = 0; i < arr.length; i++) {
//     const v = arr[i]
//     if (!seen.has(v)) { seen.add(v); res.push(v) }
//   }
//   return res
// }

// // 4) 并集/交集/差集（原始值）
// const union = (a, b) => unique(a.concat(b))
// const intersection = (a, b) => {
//   const setB = new Set(b)
//   const res = []
//   for (let i = 0; i < a.length; i++) if (setB.has(a[i])) res.push(a[i])
//   return unique(res)
// }
// const difference = (a, b) => {
//   const setB = new Set(b)
//   const res = []
//   for (let i = 0; i < a.length; i++) if (!setB.has(a[i])) res.push(a[i])
//   return res
// }

// // 5) 分组 groupBy（key 可函数或字符串）
// const groupBy = (arr, key) => {
//   const map = {}
//   const isFn = typeof key === 'function'
//   for (let i = 0; i < arr.length; i++) {
//     const item = arr[i]
//     const k = isFn ? key(item) : item && item[key]
//     const kk = String(k)
//     if (!Object.prototype.hasOwnProperty.call(map, kk)) map[kk] = []
//     map[kk].push(item)
//   }
//   return map
// }

// // 6) 计数 countBy
// const countBy = (arr, key) => {
//   const map = {}
//   const isFn = typeof key === 'function'
//   for (let i = 0; i < arr.length; i++) {
//     const item = arr[i]
//     const k = isFn ? key(item) : item && item[key]
//     const kk = String(k)
//     map[kk] = (map[kk] || 0) + 1
//   }
//   return map
// }

// // 7) 分块 chunk
// const chunk = (arr, size) => {
//   const res = []
//   if (size <= 0) return res
//   for (let i = 0; i < arr.length; i += size) {
//     const part = []
//     for (let j = i; j < i + size && j < arr.length; j++) part.push(arr[j])
//     res.push(part)
//   }
//   return res
// }

// // 8) Fisher–Yates 洗牌
// const shuffle = (arr) => {
//   const a = arr.slice()
//   for (let i = a.length - 1; i > 0; i--) {
//     const j = Math.floor(Math.random() * (i + 1))
//     const t = a[i]; a[i] = a[j]; a[j] = t
//   }
//   return a
// }

// // 9) 两数之和（返回索引，O(n)）
// const twoSum = (nums, target) => {
//   const map = new Map() // value -> index
//   for (let i = 0; i < nums.length; i++) {
//     const need = target - nums[i]
//     if (map.has(need)) return [map.get(need), i]
//     map.set(nums[i], i)
//   }
//   return [-1, -1]
// }

// // 10) 移动零（原地，保持非零相对顺序）
// const moveZeros = (nums) => {
//   let slow = 0
//   for (let fast = 0; fast < nums.length; fast++) {
//     if (nums[fast] !== 0) {
//       const t = nums[slow]; nums[slow] = nums[fast]; nums[fast] = t
//       slow++
//     }
//   }
//   // 末尾自然为 0
//   return nums
// }

// // 11) 旋转数组（右旋 k 次，原地 O(1) 空间）
// const reverse = (nums, l, r) => { while (l < r) { const t = nums[l]; nums[l] = nums[r]; nums[r] = t; l++; r-- } }
// const rotate = (nums, k) => {
//   const n = nums.length
//   if (n === 0) return nums
//   k = k % n
//   reverse(nums, 0, n - 1)
//   reverse(nums, 0, k - 1)
//   reverse(nums, k, n - 1)
//   return nums
// }

// // 12) 有序数组原地去重，返回新长度
// const removeDuplicatesInPlace = (nums) => {
//   if (nums.length === 0) return 0
//   let slow = 1
//   for (let fast = 1; fast < nums.length; fast++) {
//     if (nums[fast] !== nums[fast - 1]) nums[slow++] = nums[fast]
//   }
//   return slow
// }

// // 13) 第 k 大（快速选择，平均 O(n)）
// const kthLargest = (nums, k) => {
//   const a = nums.slice()
//   const target = a.length - k
//   let l = 0, r = a.length - 1
//   while (l <= r) {
//     const p = partition(a, l, r)
//     if (p === target) return a[p]
//     else if (p < target) l = p + 1
//     else r = p - 1
//   }
//   return NaN
// }
// const partition = (a, l, r) => {
//   const pivot = a[r]
//   let i = l
//   for (let j = l; j < r; j++) {
//     if (a[j] <= pivot) { const t = a[i]; a[i] = a[j]; a[j] = t; i++ }
//   }
//   const t = a[i]; a[i] = a[r]; a[r] = t
//   return i
// }

// // 14) 扁平化至指定深度
// const flattenDepth = (arr, depth = 1) => {
//   if (depth <= 0) return arr.slice()
//   const res = []
//   for (let i = 0; i < arr.length; i++) {
//     const item = arr[i]
//     if (Array.isArray(item)) {
//       const flat = flattenDepth(item, depth - 1)
//       for (let j = 0; j < flat.length; j++) res.push(flat[j])
//     } else {
//       res.push(item)
//     }
//   }
//   return res
// }

// // 15) 滑动窗口最大值（返回每个窗口最大值）
// const maxSlidingWindow = (nums, k) => {
//   const deque = [] // 存索引，保持单调递减
//   const res = []
//   for (let i = 0; i < nums.length; i++) {
//     while (deque.length && nums[deque[deque.length - 1]] <= nums[i]) deque.pop()
//     deque.push(i)
//     if (deque[0] <= i - k) deque.shift()
//     if (i >= k - 1) res.push(nums[deque[0]])
//   }
//   return res
// }

// // 导出以便手动测试（如需）
// module && (module.exports = {
//   flatten, deepSum, deepAverage, arrayToTree, treeToArray, unique,
//   union, intersection, difference, groupBy, chunk, countBy, shuffle,
//   twoSum, moveZeros, rotate, removeDuplicatesInPlace, kthLargest,
//   flattenDepth, maxSlidingWindow
// })
